home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / nevow / appserver.py < prev    next >
Text File  |  2008-01-31  |  13KB  |  386 lines
  1. # -*- test-case-name: nevow.test.test_appserver -*-
  2. # Copyright (c) 2004-2008 Divmod.
  3. # See LICENSE for details.
  4.  
  5. """
  6. A web application server built using twisted.web
  7. """
  8.  
  9. import cgi
  10. from urllib import unquote
  11.  
  12. from zope.interface import implements, classImplements
  13.  
  14. import twisted.python.components as tpc
  15. from twisted.web import server
  16.  
  17. try:
  18.     from twisted.web import http
  19. except ImportError:
  20.     from twisted.protocols import http
  21.  
  22. from twisted.python import log
  23. from twisted.internet import defer
  24.  
  25. from nevow import context
  26. from nevow import inevow
  27. from nevow import url
  28. from nevow import flat
  29. from nevow import stan
  30.  
  31.  
  32. class UninformativeExceptionHandler:
  33.     implements(inevow.ICanHandleException)
  34.  
  35.     def renderHTTP_exception(self, ctx, reason):
  36.         request = inevow.IRequest(ctx)
  37.         log.err(reason)
  38.         request.write("<html><head><title>Internal Server Error</title></head>")
  39.         request.write("<body><h1>Internal Server Error</h1>An error occurred rendering the requested page. To see a more detailed error message, enable tracebacks in the configuration.</body></html>")
  40.  
  41.         request.finishRequest( False )
  42.  
  43.     def renderInlineException(self, context, reason):
  44.         log.err(reason)
  45.         return """<div style="border: 1px dashed red; color: red; clear: both">[[ERROR]]</div>"""
  46.  
  47.  
  48. class DefaultExceptionHandler:
  49.     implements(inevow.ICanHandleException)
  50.  
  51.     def renderHTTP_exception(self, ctx, reason):
  52.         log.err(reason)
  53.         request = inevow.IRequest(ctx)
  54.         request.setResponseCode(http.INTERNAL_SERVER_ERROR)
  55.         request.write("<html><head><title>Exception</title></head><body>")
  56.         from nevow import failure
  57.         result = failure.formatFailure(reason)
  58.         request.write(''.join(flat.flatten(result)))
  59.         request.write("</body></html>")
  60.  
  61.         request.finishRequest( False )
  62.  
  63.     def renderInlineException(self, context, reason):
  64.         from nevow import failure
  65.         formatted = failure.formatFailure(reason)
  66.         desc = str(reason)
  67.         return flat.serialize([
  68.             stan.xml("""<div style="border: 1px dashed red; color: red; clear: both" onclick="this.childNodes[1].style.display = this.childNodes[1].style.display == 'none' ? 'block': 'none'">"""),
  69.             desc,
  70.             stan.xml('<div style="display: none">'),
  71.             formatted,
  72.             stan.xml('</div></div>')
  73.         ], context)
  74.  
  75.  
  76. errorMarker = object()
  77.  
  78.  
  79. def processingFailed(reason, request, ctx):
  80.     try:
  81.         handler = inevow.ICanHandleException(ctx)
  82.         handler.renderHTTP_exception(ctx, reason)
  83.     except:
  84.         request.setResponseCode(http.INTERNAL_SERVER_ERROR)
  85.         log.msg("Exception rendering error page:", isErr=1)
  86.         log.err()
  87.         log.err("Original exception:", isErr=1)
  88.         log.err(reason)
  89.         request.write("<html><head><title>Internal Server Error</title></head>")
  90.         request.write("<body><h1>Internal Server Error</h1>An error occurred rendering the requested page. Additionally, an error occured rendering the error page.</body></html>")
  91.         request.finishRequest( False )
  92.  
  93.     return errorMarker
  94.  
  95.  
  96. def defaultExceptionHandlerFactory(ctx):
  97.     return DefaultExceptionHandler()
  98.  
  99.  
  100. class NevowRequest(tpc.Componentized, server.Request):
  101.     """
  102.     A Request subclass which does additional
  103.     processing if a form was POSTed. When a form is POSTed,
  104.     we create a cgi.FieldStorage instance using the data posted,
  105.     and set it as the request.fields attribute. This way, we can
  106.     get at information about filenames and mime-types of
  107.     files that were posted.
  108.  
  109.     TODO: cgi.FieldStorage blocks while decoding the MIME.
  110.     Rewrite it to do the work in chunks, yielding from time to
  111.     time.
  112.  
  113.     @ivar fields: C{None} or, if the HTTP method is B{POST}, a
  114.         L{cgi.FieldStorage} instance giving the content of the POST.
  115.     """
  116.     implements(inevow.IRequest)
  117.  
  118.     fields = None
  119.  
  120.     def __init__(self, *args, **kw):
  121.         server.Request.__init__(self, *args, **kw)
  122.         tpc.Componentized.__init__(self)
  123.  
  124.     def process(self):
  125.         # extra request parsing
  126.         if self.method == 'POST':
  127.             t = self.content.tell()
  128.             self.content.seek(0)
  129.             self.fields = cgi.FieldStorage(self.content, self.received_headers,
  130.                                            environ={'REQUEST_METHOD': 'POST'})
  131.             self.content.seek(t)
  132.  
  133.         # get site from channel
  134.         self.site = self.channel.site
  135.  
  136.         # set various default headers
  137.         self.setHeader('server', server.version)
  138.         self.setHeader('date', server.http.datetimeToString())
  139.         self.setHeader('content-type', "text/html; charset=UTF-8")
  140.  
  141.         # Resource Identification
  142.         self.prepath = []
  143.         self.postpath = map(unquote, self.path[1:].split('/'))
  144.         self.sitepath = []
  145.  
  146.         self.deferred = defer.Deferred()
  147.  
  148.         requestContext = context.RequestContext(parent=self.site.context, tag=self)
  149.         requestContext.remember( (), inevow.ICurrentSegments)
  150.         requestContext.remember(tuple(self.postpath), inevow.IRemainingSegments)
  151.  
  152.         return self.site.getPageContextForRequestContext(
  153.             requestContext
  154.         ).addErrback(
  155.             processingFailed, self, requestContext
  156.         ).addCallback(
  157.             self.gotPageContext
  158.         )
  159.  
  160.     def gotPageContext(self, pageContext):
  161.         if pageContext is not errorMarker:
  162.             return defer.maybeDeferred(
  163.                 pageContext.tag.renderHTTP, pageContext
  164.             ).addBoth(
  165.                 self._cbSetLogger, pageContext
  166.             ).addErrback(
  167.                 processingFailed, self, pageContext
  168.             ).addCallback(
  169.                 self._cbFinishRender, pageContext
  170.             )
  171.  
  172.     def finish(self):
  173.         self.deferred.callback("")
  174.  
  175.     def finishRequest( self, success ):
  176.         server.Request.finish(self)
  177.  
  178.     def _cbFinishRender(self, html, ctx):
  179.         if isinstance(html, str):
  180.             self.write(html)
  181.             self.finishRequest(  True )
  182.         elif html is errorMarker:
  183.             ## Error webpage has already been rendered and finish called
  184.             pass
  185.         else:
  186.             res = inevow.IResource(html)
  187.             pageContext = context.PageContext(tag=res, parent=ctx)
  188.             return self.gotPageContext(pageContext)
  189.         return html
  190.  
  191.     _logger = None
  192.     def _cbSetLogger(self, result, ctx):
  193.         try:
  194.             logger = ctx.locate(inevow.ILogger)
  195.         except KeyError:
  196.             pass
  197.         else:
  198.             self._logger = lambda : logger.log(ctx)
  199.  
  200.         return result
  201.  
  202.     session = None
  203.  
  204.     def getSession(self, sessionInterface=None):
  205.         if self.session is not None:
  206.             self.session.touch()
  207.             if sessionInterface:
  208.                 return sessionInterface(self.session)
  209.             return self.session
  210.         ## temporary until things settle down with the new sessions
  211.         return server.Request.getSession(self, sessionInterface)
  212.  
  213.     def URLPath(self):
  214.         return url.URL.fromContext(self)
  215.  
  216.     def rememberRootURL(self, url=None):
  217.         """
  218.         Remember the currently-processed part of the URL for later
  219.         recalling.
  220.         """
  221.         if url is None:
  222.             return server.Request.rememberRootURL(self)
  223.         else:
  224.             self.appRootURL = url
  225.  
  226.  
  227. def sessionFactory(ctx):
  228.     """Given a RequestContext instance with a Request as .tag, return a session
  229.     """
  230.     return ctx.tag.getSession()
  231.  
  232. requestFactory = lambda ctx: ctx.tag
  233.  
  234.  
  235. class NevowSite(server.Site):
  236.     requestFactory = NevowRequest
  237.  
  238.     def __init__(self, resource, *args, **kwargs):
  239.         resource.addSlash = True
  240.         server.Site.__init__(self, resource, *args, **kwargs)
  241.         self.context = context.SiteContext()
  242.  
  243.     def remember(self, obj, inter=None):
  244.         """Remember the given object for the given interfaces (or all interfaces
  245.         obj implements) in the site's context.
  246.  
  247.         The site context is the parent of all other contexts. Anything
  248.         remembered here will be available throughout the site.
  249.         """
  250.         self.context.remember(obj, inter)
  251.  
  252.     def getPageContextForRequestContext(self, ctx):
  253.         """Retrieve a resource from this site for a particular request. The
  254.         resource will be wrapped in a PageContext which keeps track
  255.         of how the resource was located.
  256.         """
  257.         path = inevow.IRemainingSegments(ctx)
  258.         res = inevow.IResource(self.resource)
  259.         pageContext = context.PageContext(tag=res, parent=ctx)
  260.         return defer.maybeDeferred(res.locateChild, pageContext, path).addCallback(
  261.             self.handleSegment, ctx.tag, path, pageContext
  262.         )
  263.  
  264.     def handleSegment(self, result, request, path, pageContext):
  265.         if result is errorMarker:
  266.             return errorMarker
  267.  
  268.         newres, newpath = result
  269.         # If the child resource is None then display a 404 page
  270.         if newres is None:
  271.             from nevow.rend import FourOhFour
  272.             return context.PageContext(tag=FourOhFour(), parent=pageContext)
  273.  
  274.         # If we got a deferred then we need to call back later, once the
  275.         # child is actually available.
  276.         if isinstance(newres, defer.Deferred):
  277.             return newres.addCallback(
  278.                 lambda actualRes: self.handleSegment(
  279.                     (actualRes, newpath), request, path, pageContext))
  280.  
  281.  
  282.         #
  283.         # FIX A GIANT LEAK. Is this code really useful anyway?
  284.         #
  285.         newres = inevow.IResource(newres)#, persist=True)
  286.         if newres is pageContext.tag:
  287.             assert not newpath is path, "URL traversal cycle detected when attempting to locateChild %r from resource %r." % (path, pageContext.tag)
  288.             assert  len(newpath) < len(path), "Infinite loop impending..."
  289.  
  290.         ## We found a Resource... update the request.prepath and postpath
  291.         for x in xrange(len(path) - len(newpath)):
  292.             if request.postpath:
  293.                 request.prepath.append(request.postpath.pop(0))
  294.  
  295.         ## Create a context object to represent this new resource
  296.         ctx = context.PageContext(tag=newres, parent=pageContext)
  297.         ctx.remember(tuple(request.prepath), inevow.ICurrentSegments)
  298.         ctx.remember(tuple(request.postpath), inevow.IRemainingSegments)
  299.  
  300.         res = newres
  301.         path = newpath
  302.  
  303.         if not path:
  304.             return ctx
  305.  
  306.         return defer.maybeDeferred(
  307.             res.locateChild, ctx, path
  308.         ).addErrback(
  309.             processingFailed, request, ctx
  310.         ).addCallback(
  311.             self.handleSegment, request, path, ctx
  312.         )
  313.  
  314.     def log(self, request):
  315.         if request._logger is None:
  316.             server.Site.log(self, request)
  317.         else:
  318.             request._logger()
  319.  
  320.  
  321. ## This should be moved somewhere else, it's cluttering up this module.
  322.  
  323. class OldResourceAdapter(object):
  324.     implements(inevow.IResource)
  325.  
  326.     # This is required to properly handle the interaction between
  327.     # original.isLeaf and request.postpath, from which PATH_INFO is set in
  328.     # twcgi. Because we have no choice but to consume all elements in
  329.     # locateChild to terminate the recursion, we do so, but first save the
  330.     # length of prepath in real_prepath_len. Subsequently in renderHTTP, if
  331.     # real_prepath_len is not None, prepath is correct to the saved length and
  332.     # the extra segments moved to postpath. If real_prepath_len is None, then
  333.     # locateChild has never been called, so we know not the real length, so we
  334.     # do nothing, which is correct.
  335.     real_prepath_len = None
  336.  
  337.     def __init__(self, original):
  338.         self.original = original
  339.  
  340.     def __repr__(self):
  341.         return "<%s @ 0x%x adapting %r>" % (self.__class__.__name__, id(self), self.original)
  342.  
  343.     def locateChild(self, ctx, segments):
  344.         request = inevow.IRequest(ctx)
  345.         if self.original.isLeaf:
  346.             self.real_prepath_len = len(request.prepath)
  347.             return self, ()
  348.         name = segments[0]
  349.         request.prepath.append(request.postpath.pop(0))
  350.         res = self.original.getChildWithDefault(name, request)
  351.         request.postpath.insert(0, request.prepath.pop())
  352.         if isinstance(res, defer.Deferred):
  353.             return res.addCallback(lambda res: (res, segments[1:]))
  354.         return res, segments[1:]
  355.  
  356.     def _handle_NOT_DONE_YET(self, data, request):
  357.         if data == server.NOT_DONE_YET:
  358.             return request.deferred
  359.         else:
  360.             return data
  361.  
  362.     def renderHTTP(self, ctx):
  363.         request = inevow.IRequest(ctx)
  364.         if self.real_prepath_len is not None:
  365.             path = request.postpath = request.prepath[self.real_prepath_len:]
  366.             del request.prepath[self.real_prepath_len:]
  367.         result = defer.maybeDeferred(self.original.render, request).addCallback(
  368.             self._handle_NOT_DONE_YET, request)
  369.         return result
  370.  
  371.     def willHandle_notFound(self, request):
  372.         if hasattr(self.original, 'willHandle_notFound'):
  373.             return self.original.willHandle_notFound(request)
  374.         return False
  375.  
  376.     def renderHTTP_notFound(self, ctx):
  377.         return self.original.renderHTTP_notFound(ctx)
  378.  
  379.  
  380. from nevow import rend
  381.  
  382. NotFound = rend.NotFound
  383. FourOhFour = rend.FourOhFour
  384.  
  385. classImplements(server.Session, inevow.ISession)
  386.